#ifndef _VISITORBASE_H_
#define _VISITORBASE_H_
#include "IVisitor.h"
#include "SimpleNode.h"
#include "Object.h"
#include "ast/Assert.h"
#include "ast/Assign.h"
#include "ast/Attribute.h"
#include "ast/AugAssign.h"
#include "ast/BinOp.h"
#include "ast/BoolOp.h"
#include "ast/Break.h"
#include "ast/Call.h"
#include "ast/ClassDef.h"
#include "ast/Compare.h"
#include "ast/Comprehension.h"
#include "ast/Continue.h"
#include "ast/Delete.h"
#include "ast/Dict.h"
#include "ast/DictComp.h"
#include "ast/Ellipsis.h"
#include "ast/Expr.h"
#include "ast/Expression.h"
#include "ast/ExtSlice.h"
#include "ast/For.h"
#include "ast/FunctionDef.h"
#include "ast/GeneratorExp.h"
#include "ast/Global.h"
#include "ast/If.h"
#include "ast/IfExp.h"
#include "ast/Import.h"
#include "ast/ImportFrom.h"
#include "ast/Index.h"
#include "ast/Interactive.h"
#include "ast/Lambda.h"
#include "ast/List.h"
#include "ast/ListComp.h"
#include "ast/Module.h"
#include "ast/Name.h"
#include "ast/NameTok.h"
#include "ast/NonLocal.h"
#include "ast/Num.h"
#include "ast/Pass.h"
#include "ast/Raise.h"
#include "ast/Repr.h"
#include "ast/Return.h"
#include "ast/Set.h"
#include "ast/SetComp.h"
#include "ast/Slice.h"
#include "ast/Starred.h"
#include "ast/Str.h"
#include "ast/StrJoin.h"
#include "ast/Subscript.h"
#include "ast/TryExcept.h"
#include "ast/TryFinally.h"
#include "ast/Tuple.h"
#include "ast/UnaryOp.h"
#include "ast/While.h"
#include "ast/With.h"
#include "ast/WithItem.h"
#include "ast/Yield.h"
#include "ast/Suite.h"


class VisitorBase: public IVisitor
{
public:
    
    virtual void visitAssert(const AssertPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitAssign(const AssignPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitAttribute(const AttributePtr& node)
    {
        traverse(node);
    }
    
    virtual void visitAugAssign(const AugAssignPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitBinOp(const BinOpPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitBoolOp(const BoolOpPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitBreak(const BreakPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitCall(const CallPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitClassDef(const ClassDefPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitCompare(const ComparePtr& node)
    {
        traverse(node);
    }
    
    virtual void visitComprehension(const ComprehensionPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitContinue(const ContinuePtr& node)
    {
        traverse(node);
    }
    
    virtual void visitDelete(const DeletePtr& node)
    {
        traverse(node);
    }
    
    virtual void visitDict(const DictPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitDictComp(const DictCompPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitEllipsis(const EllipsisPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitExpr(const ExprPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitExpression(const ExpressionPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitExtSlice(const ExtSlicePtr& node)
    {
        traverse(node);
    }
    
    virtual void visitFor(const ForPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitFunctionDef(const FunctionDefPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitGeneratorExp(const GeneratorExpPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitGlobal(const GlobalPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitIf(const IfPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitIfExp(const IfExpPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitImport(const ImportPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitImportFrom(const ImportFromPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitIndex(const IndexPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitInteractive(const InteractivePtr& node)
    {
        traverse(node);
    }
    
    virtual void visitLambda(const LambdaPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitList(const ListPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitListComp(const ListCompPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitModule(const ModulePtr& node)
    {
        traverse(node);
    }
    
    virtual void visitName(const NamePtr& node)
    {
        traverse(node);
    }
    
    virtual void visitNameTok(const NameTokPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitNonLocal(const NonLocalPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitNum(const NumPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitPass(const PassPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitRaise(const RaisePtr& node)
    {
        traverse(node);
    }
    
    virtual void visitRepr(const ReprPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitReturn(const ReturnPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitSet(const SetPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitSetComp(const SetCompPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitSlice(const SlicePtr& node)
    {
        traverse(node);
    }
    
    virtual void visitStarred(const StarredPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitStr(const StrPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitStrJoin(const StrJoinPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitSubscript(const SubscriptPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitTryExcept(const TryExceptPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitTryFinally(const TryFinallyPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitTuple(const TuplePtr& node)
    {
        traverse(node);
    }
    
    virtual void visitUnaryOp(const UnaryOpPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitWhile(const WhilePtr& node)
    {
        traverse(node);
    }
    
    virtual void visitWith(const WithPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitWithItem(const WithItemPtr& node)
    {
        traverse(node);
    }
    
    virtual void visitYield(const YieldPtr& node)
    {
        traverse(node);
    }
    

    virtual void visitSuite(const SuitePtr & node)
    {
        traverse(node);
    }
    
    virtual void traverse(const SimpleNodePtr& node) = 0;
protected:
    virtual void unhandled_node(const SimpleNodePtr& node) = 0;
};

#endif